Linux Cubed Series 3: Developer Tools

home *** CD-ROM | disk | FTP | other *** search

/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / ada / gnat-3.05- / gnat-3 / gnat-3.05-i486-linux-elf-bin / features < prev next >

Wrap

Text File | 1996-06-11 | 34.9 KB | 834 lines

GNAT IMPLEMENTED FEATURES LIST Current as of 05/17/96 Here is the list of implemented and not implemented features, including a full description of implementation-defined pragmas and attributes. For information on how to use GNAT, see gnatinfo.txt. Latest features in GNAT version 3.05w ===================================== Implement packing for bit field sizes up to 31 (major) Latest features in GNAT version 3.04 ==================================== GNAT attributes mantissa, safe_small for fixed points GNAT attribute small for floating point These attributes correspond to attributes defined in Ada 83. gnatlink (new utility program) pragma Unchecked_Union is fully implemented (see end of this document) More efficient execution of programs containing exception handlers (especially on Sun Sparc) Many new options to gnatmake: (see gnatinfo.txt for details) -aI -aO, -jnum, -k, -l, -o New Source & Library search path switches: (see gnatinfo.txt for details) -aLdir, -Adir, -aOdir, -aIdir, -Idir, -I-, -Ldir The DOS version has been migrated to DJGPP v2. Tasking is now fully functional in the DOS version. "Real" memory problems in the DOS version have been alleviated. New warnings for some infinite recursion cases When an Assert_Failure exception is raised, the exception is raised with a message, either the file name and line number by default of the pragma Assert, or the string explicitly supplied as the second parameter. The restriction names No_GNAT_Attributes and No_GNAT_Pragmas have been renamed No_Implementation_Attributes and No_Implementation_Pragmas. Record Representation Clauses which do not specify representations for all components (partial rep clauses) are now accepted by GNAT. Packed arrays of records are now implemented. The Size attribute is now handled as specified in the RM. This means that the value of 'Size will often be different from what it was before and what it was in Ada 83. Two new attributes Object_Size and Value_Size have been added to provide additional control. Latest features in GNAT version 3.03 ==================================== Implement packing of multidimensional arrays Get_Immediate now follows the implementation advice and works as intended (for SGI IRIX, Sparc SunOS/Solaris, Alpha OSF1, IBM OS/2 and Linux) The task attributes package is now fully functional Warnings for unset variables, and possible access before initialization pragma Warnings (On | Off) allows more detailed control of warnings pragma Source_File_Name allows specifying non-standard file names pragma No_Return allows specifying a procedure that never returns pragma Attach_Handler (implemented on Sparc SunOS and Sparc Solaris only) pragma Interrupt_Handler (implemented on Sparc SunOS and Sparc Solaris only) Latest features in GNAT version 3.01 ==================================== pragma Normalize_Scalars Ada.Text_IO.Editing Ada.Wide_Text_IO.Editing Incomplete types declared in the private part that are completed in the package body as unconstrained arrays. Full implementation of stream attributes, including the dispatching cases for class wide types. Private protected operations Pointers to unconstrained arrays may be double or single length. Double ("fat") is the default size (e.g. 64 on SGI), but rep clauses or a foreign convention will force them to single length. Aggregates for composite Types with controlled components Objects of type with unknown discriminants pragma Queuing_Policy pragma Source_File_Name (GNAT specific) True multiprocessing on Sparc Solaris Latest features in GNAT version 2.07 ==================================== Discriminant checks Package Ada.Exceptions External_Tag attribute Identity attribute Range Checks on the elaboration of a subtype_indication Duration is an ordinary fixed-point type with delta of one nanosecond Package Interfaces.COBOL Protected subprogram pointers Caller attribute Restriction pragma All restrictions in real time annex All restrictions in safety and security annex Higher resolution clocks for tasking on SunOS/Solaris Latest features in GNAT version 2.06 ==================================== Requeue Statement involving task entries inter-unit inlining (enabled by -O2 -gnatn) aggregates for simple controlled types Latest features in GNAT version 2.05 ==================================== Elaboration Checks A new switch -gnati8 specifies the use of IBM PC Code Page 850 for the identifier character set (this is Latin-1 a la IBM PC) Protected entry families Ada.Synchronous_Task_Control Attribute Storage_Pool Packed arrays (including packed boolean arrays) Accessibility checks -I for specifying source and object path (see gnatinfo.txt for details) Conditional protected entry calls Delay until inside select statements Latest features in GNAT version 2.04 ==================================== GNATMAKE utility (see gnatinfo.txt for details) Pragma Export Ada.Streams.Stream_IO Attribute Definite Interrupt entries Input-Output for Modular Types Input-Output for Decimal Types Input-Output for Integer for type Long_Long_Integer. The following are now implemented in package Ada.Text_IO Flush Look_Ahead Get_Immediate Text_IO.Complex_IO Text_IO.Text_Streams Wide_Text_IO Wide_Text_IO.Complex_IO Wide_Text_IO.Text_Streams Note: All the I/O packages have been rewritten from the ground up for this release, and should completely implement all features of the RM. To get file sharing, allowed only if the files are for the same I/O package and same mode, use a form parameter shared=yes. Status of Features This list applies to the ports for the following targets: SGI IRIX 5.2 Sun Sparc (SunOS 4.1 and Solaris 2.3), x86 running IBM OS/2, Linux Other targets are generally complete except that no tasking constructs are implemented. ========================================================== = All of Ada 83 is implemented EXCEPT for the following: = ========================================================== Stack overflow checking is implemented only on the SGI machines ========================================================================= = All of Ada 95 implemented EXCEPT the following unimplemented features = ========================================================================= CORE (fully implemented) ANNEX A. PREDEFINED LANGUAGE ENVIRONMENT Ada.Interrupts (implemented on Sparc SunOS and Sparc Solaris only) ANNEX B. INTERFACING TO OTHER LANGUAGES (fully implemented) ANNEX C. SYSTEMS PROGRAMMING Machine intrinsic subprograms Interrupt support (implemented on Sparc SunOS and Sparc Solaris only) Ada.Interrupts (implemented on Sparc SunOS and Sparc Solaris only) Record rep clauses require full specification ANNEX D. REAL-TIME SYSTEMS (fully implemented) ANNEX E. DISTRIBUTED SYSTEMS (fully implemented) (this refers to the compiler part, stub generation and the pragmas) ANNEX F. INFORMATION SYSTEMS (fully implemented) ANNEX G. NUMERICS Accuracy requirements for floating-point and complex not fully met ANNEX H. SAFETY AND SECURITY (fully implemented) ANNEX I. OBSOLESCENT FEATURES (fully implemented) ANNEX J. LANGUAGE-DEFINED ATTRIBUTES (fully implemented) ANNEX K. LANGUAGE DEFINED PRAGMAS Attach_Handler (implemented on Sparc SunOS and Sparc Solaris only) Interrupt_Handler (implemented on Sparc SunOS and Sparc Solaris only) ================================ = Description of GNAT Pragmas == ================================ pragma Abort_Defer; This pragma is implementation (GNAT) defined. It must appear at the start of the statement sequence of a handled sequence of statements (right after the begin). It has the effect of deferring aborts for the sequence of statements (but not for the declarations or handlers, if any, associated with this statement sequence). The exception case is handled correctly, i.e. if the statement sequence propagates an exception, then abort is properly undeferred. pragma Ada_83; This pragma is implementation (GNAT) defined. It establishes Ada 83 mode for following text, regardless of the mode set by the command line switches. Note that this is not a configuration pragma, so it must be given separately for each unit to which it applies. pragma Ada_95; This pragma is implementation (GNAT) defined. It establishes Ada 95 mode for following text, regardless of the mode set by the command line switches. Note that this is not a configuration pragma, so it must be given separately for each unit to which it applies. Note: Ada 95 mode is set automatically for predefined language units, including children of GNAT, so need not be given for any such units. pragma Annotate (IDENTIFIER {, ARG}); ARG ::= NAME | EXPRESSION This pragma is an implementation (GNAT) defined pragma used to annotate programs. The first argument is simply an identifier that identifies the type of annotation. GNAT verifies that this is an identifier, but does not otherwise analyze it. The arguments following this identifier are analyzed as follows: String literals are assumed to be of type Standard.String Names of entities are simply analyzed as entity names All other expressions are analyzed as expressions, and must be unambiguous The analyzed pragma is retained in the tree, but not otherwise processed by any part of the GNAT compiler. This pragma is intended for use by external tools. pragma Assert (Boolean_EXPRESSION [,static_string_EXPRESSION]); This pragma is implementation (GNAT) defined. Its effect depends on whether the corresponding command line switch is set to activate assertions. If assertions are inactive, the pragma has no effect. If asserts are enabled, then the semantics of the pragma is exactly equivalent to: if not Boolean_EXPRESSION then System.Assertions.Raise_Assert_Failure (string_EXPRESSION); end if; The effect of the call is to raise System.Assertions.Assert_Failure. The string argument, if given, is the message associated with the exception occurrence. If no second argument is given, the default message is "file:nnn", where file is the name of the source file containing the assert, and nnn is the line number of the assert. Note: a pragma is not a statement, so if a statement sequence contains nothing but a pragma assert, then a null statement is required in addition, as in: ... if J > 3 then pragma (Assert (K > 3, "Bad value for K")); null; end if; Note: if the boolean expression has side effects, then these side effects will turn on and off with the setting of the assertions mode, resulting in assertions that have an effect on the program. This should generally be avoided. pragma CPP_Class ([Entity =>] LOCAL_NAME) The argument denotes an entity in the current declarative region that is declared as a tagged or untagged record type. It indicates that the type corresponds to an externally declared C++ class type, and is to be layed out the same way that C++ would lay out the type. If (and only if) the type is tagged, at least one component in the record must be of type Interfaces.CPP.Vtable_Ptr, corresponding to the C++ Vtable (or Vtables in the case of multiple inheritance) used for dispatching. Types for which CPP_Class is defined do not have assignment or equality operators defined (such operations can be imported or declared as subprograms as required). Initialization is allowed only by constructor functions (see pragma CPP_Constructor). pragma CPP_Constructor ([Entity =>] LOCAL_NAME); This pragma identifies an imported function (imported in the usual way with pragma Import) as corresponding to a C++ constructor. The identified function must be previously mentioned in a pragma Import with convention C++, and must be of one of the following forms: function Fname return T'Class; function Fname (<parameters>) return T'Class; where T is a tagged type to which the pragma CPP_Class applies. The first form is the default constructor, used when an object of type T is created on the Ada side with no explicit constructor. Other constructors (including the copy constructor, which is simply a special case of the second form in which the one and only argument is of type T), can only appear in two contexts: On the right side of an initialization of an object of type T In an extension aggregate for an object of a type derived from T Note that although the constructor is described as a function that returns a value on the Ada side, it is typically a procedure with an extra implicit argument (the object being initialized) at the implementation level. GNAT takes care of issuing the appropriate call, whatever it is, to get the object properly initialized. Note: in the case of derived objects, there are two possible forms for declaring and creating an object: New_Object : Derived_T; New_Object : Derived_T := (constructor-function-call with ...); In the first case the default constructor is called, and extension fields if any are initialized according to the default initialization expressions in the Ada declaration. In the second case, the given constructor is called, and the extension aggregate indicates the explicit values of the extension fields. Note: if no constructors are imported then it is impossible to create any objects on the Ada side. If no default constructor is imported, then only the initialization forms using an explicit call to a constructor are permitted. pragma CPP_Destructor ([Entity =>] LOCAL_NAME); This pragma identifies an imported procedure (imported in the usual way with pragma Import) as corresponding to a C++ destructor. The identified procedure must be previously mentioned in a pragma Import with convention C++, and must be of the following forms: procedure Fname (obj : in out T'Class); where T is a tagged type to which the pragma CPP_Class applies. This procedure will be called automaticlly on scope exit if any objects of T are created on the Ada side. pragma CPP_Virtual [Entity =>] LOCAL_NAME [ [Vtable_Ptr =>] Component_NAME, [Position =>] static_integer_EXPRESSION]); This pragma serves the same function as pragma Import for the case of a virtual function that is imported from C++. Entity must refer to a primitive subprogram of a tagged type to which pragma CPP_Class applies. Vtable_Ptr specifies the Vtable_Ptr component which contains the entry for this virtual function, and Position is the sequential number counting virtual functions for this Vtable starting at 1. The Vtable_Ptr and Position arguments may be omitted if there is one Vtable_Ptr present (single inheritance case), and all virtual functions are imported, since then the compiler can deduce both these values. Note that no External_Name or Link_Name arguments are required for a virtual function, since it is always accessed indirectly via the appropriate Vtable entry. pragma CPP_Vtable ( [Entity =>] LOCAL_NAME [Vtable_Ptr =>] Component_NAME, [Entry_Count =>] static_integer_EXPRESSION); One CPP_Vtable pragma can be present for each component of type CPP.Interfaces.Vtable_Ptr in a record to which pragma CPP_Class applies. Entity is the tagged type, Vtable_Ptr is the record field of type Vtable_Ptr, and Entry_Count is the number of virtual functions on the C++ side (not all of which need to be imported on the Ada side). It is permissible to omit the CPP_Vtable pragma if there is only one Vtable_Ptr component in the record, and all virtual functions are imported on the Ada side (the default value for the entry count in this case is simply the total number of virtual functions). pragma Debug (PROCEDURE_CALL_STATEMENT); This pragma is implementation (GNAT) defined. Its effect depends on the setting of the Assertions_Enabled flag in Opt. If this flag is off (False), then the pragma has no effect. If the flag is on (True), then the semantics of the pragma is equivalent to the procedure call. pragma Error_Monitoring (On | Off, STRING_LITERAL) This pragma is implementation (GNAT) defined. It is used to bracket a section of code, using one pragma with argument ON to start the section, and another with argument OFF to end the section. Within the monitored section of code, any error message issued will be considered a warning from the point of view of the return code issued by the compilation. Furthermore at least one such error must occur within each monitored region. If no error occurs, a fatal (non-warning) message is issued. The use of the pragma Error_Monitoring causes code generation to be turned off (since there really are errors in the program). If a second argument is given, then there is an additional check that the first error issued in the monitored region exactly matches the characters given in the string literal. The second argument is only relevant for the ON case, it is ignored for the OFF case. This pragma is provided to allow easy automation of error message generation, e.g. in ACVC B tests, and is primarily intended for compiler testing purposes. pragma Inline_Generic (generic_package_NAME) This is implemented for compatibility with Dec, and is recognized, but otherwise ignored by GNAT. pragma Interface_Name ( [Entity =>] LOCAL_NAME [,[External_Name =>] static_string_EXPRESSION]] [,[Link_Name =>] static_string_EXPRESSION]] ); This pragma is implementation (GNAT) defined. It is an alternative way of specifying the interface name for an interfaced subprogram, and is provided for compatibility with Ada 83 compilers that use the pragma for this purpose. At least one of the arguments external name or link name must be present. pragma Machine_Attribute ( [Attribute_Name =>] static_string_EXPRESSION ,[Entity =>] LOCAL_NAME ); This pragma is implementation (GNAT) defined. Machine dependent attributes can be specified for types and/or declarations. Currently only subprogram entities are supported. This pragma is semantically equivalent to __attribute__(( <Attribute_Name> )) in Gnu C, where <Attribute_Name> is recognized by the Gnu C macros: VALID_MACHINE_TYPE_ATTRIBUTE VALID_MACHINE_DECL_ATTRIBUTE, which are defined in the configuration header file tm.h. Further documentation can be found in the gcc distribution document: tm.texi. pragma No_Return (procedure_LOCAL_NAME); The given name must refer to one or more procedure declarations in the current declarative part. A procedure to which this pragma is applied may not contain any explicit return statements, and also may not contain any implicit return statements from falling off the end of a statement sequence. One use of this pragma is to identify procedures whose only purpose is to raise an exception. One use of this pragma is to suppress incorrect warnings about missing returns in functions, where the last statement of a function statement sequence is a call to such a procedure. pragma Share_Generic (generic_package_NAME) This is implemented for compatibility with Dec, and is recognized, but otherwise ignored by GNAT. pragma Source_File_Name ( [UNIT_NAME =>] unit_NAME, [BODY_FILE_NAME | SPEC_FILE_NAME] => STRING_LITERAL) The source file name pragma allows a program to override the normal naming convention. It is a configuration pragma, and so has the usual applicability of configuration pragmas (i.e. it applies to either an entire partition, or to all units in a compilation, or to a single unit, depending on how it is used. The form of the pragma is: The given unit name is mapped to the given file name. The identifier for the second argument is required, and indicates whether this is the file name for the spec or for the body. pragma Source_Reference (INTEGER_LITERAL [, STRING_LITERAL]); This pragma is implementation (GNAT) defined. It typically appears as the first line of a source file. The integer value is the logical line number of the line following the pragma line (for use in error messages and debugging information). The second argument is a static string constant that specifies the file name to be used in error messages and debugging information. This is most notably used for the output of gnatchop with the -r switch, to make sure that the original unchopped source file is the one referred to. Note: the second argument must be a string literal, it cannot be a static string expression other than a string literal. This is because its value is needed for error messages issued by all phases of the compiler. pragma Subtitle (...) Recognized but ignored pragma Task_Info (task_info_EXPRESSION) This pragma appears within a task definition (like pragma Priority) and applies to the task in which it appears. The argument must be of type System.Task_Info.Task_Info_Type. pragma Title (...) Recognized but ignored pragma Unchecked_Union (first_subtype_LOCAL_NAME) This pragma is implementation (GNAT) defined. It is used to declare that the named type should be equivalent to a C union type, and is intended only for use in interfacing with C code that uses union types. In Ada terms, the named type must obey the following rules: It is a non-tagged non-limited record type It has a single discrete discriminant with a default value Pragma Suppress (Discriminant_Check) applies implicitly The component list consists of a single variant part The default convention is C Each variant has a component list with a single component No nested variants are allowed No component can have an explicit default value No component can have a non-static constraint In addition, given a type that meets the above requirements, the following restrictions apply to its use throughout the program: The discriminant name can be mentioned only in an aggregate No subtypes may be created of this type The type may not be constrained by giving a discriminant value An unchecked union type cannot be passed as the actual for a generic formal with a discriminant. Also, equality and inequality operations on unchecked_unions are not available, since there is no discriminant to compare, and in general the compiler does not even know how many bits to compare. It is implementation dependent whether this is detected at compile time as an illegality, or whether it is undetected and considered to be an erroneous construct. In GNAT, a direct comparison is illegal, but GNAT does not attempt to catch the composite case (where two composites are compared that contain an unchecked union component), so such comparisons are simply considered erroneous. The layout of the resulting type corresponds exactly to a C union, where each branch of the union corresponds to a single variant in the Ada record. The semantics of the Ada program is not changed in any way by the pragma, i.e. provided the above restrictions are followed, and no erroneous incorrect references to fields or erroneous comparisons occur, the semantics is exactly as described by the Ada reference manual. pragma Unimplemented_Unit; This pragma is implementation (GNAT) defined. If it occurs in a unit that is processed by the compiler, the compilation is aborted with the message xxx not implemented, where xxx is the name of the current compilation unit followed by a compiler abort. This pragma is intended to allow the compiler to handle unimplemented library units in a clean manner. The abort only hapens if code is being generated. This allows the use of specs of unimplemented packages in syntax or semantic checking mode. pragma Unsuppress (IDENTIFIER [, [On =>] NAME]); This pragma is an implementation (GNAT) defined configuration pragma. It undoes the effect of a previous pragma Suppress. If there is no corresponding pragma Suppress in effect, then it has no effect. The range of the effect is the same as for pragma Suppress. The meaning of the arguments is identical to that used in pragma Suppress. One important application is to ensure that checks are on in cases where code depends on the checks for its correct functioning, so that the code will compile correctly even if the compiler switches are set to suppress checks. Pragma Warnings (On | Off, [LOCAL_NAME]); Normally warnings are enabled, with the output being controlled by the command line switch. Warnings (Off) turns off generation of warnings until a Warnings (On) is encountered or the end of the current unit. If generation of warnings is turned off using this pragma, then no warning messages are output, regardless of the setting of the command line switches. The form with a single argument is a configuration pragma. If a second parameter is present, then warnings are suppressed for the particular entity named in the pragma. This suppression is effective from the point where it occurs till the end of the extended scope of the variable (similar to the scope of Suppress). ========================================== = Description of GNAT-defined Attributes = ========================================== Abort_Signal Standard'Abort_Signal (Standard is the only allowed prefix) provides the entity for the special exception used to signal task abort or asynchronous transfer of control. Normally this attribute should only be used in the tasking runtime (it is highly peculiar, and completely outside the normal semantics of Ada, for a user program to intercept the abort exception). Address_Size Standard'Address_Size (Standard is the only allowed prefix) is a static constant giving the number of bits in an Address. It is used primarily for constructing the definition of Memory_Size in package Standard, but may be freely used in user programs. This is a static attribute. Default_Bit_Order Standard'Default_Bit_Order (Standard is the only permissible prefix), provides the value System.Default_Bit_Order as a Pos value (0 for High_Order_First, 1 for Low_Order_First). This is used to construct the definition of Default_Bit_Order in package System. This is a static attribute. Elab_Body This attribute can only be applied to a program unit name. It returns the entity for the corresponding elaboration procedure for elaborating the body of the referenced unit. This is used in the main generated elaboration procedure by the binder, and is not normally used in any other context, but there may be specialized situations in which it is useful to be able to call this elaboration procedure from Ada code, e.g. if it is necessary to do selective reelaboration to fix some error. Elab_Spec This attribute can only be applied to a program unit name. It returns the entity for the corresponding elaboration procedure for elaborating the spec of the referenced unit. This is used in the main generated elaboration procedure by the binder, and is not normally used in any other context, but there may be specialized situations in which it is useful to be able to call this elaboration procedure from Ada code, e.g. if it is necessary to do selective reelaboration to fix some error. Enum_Rep For every enumeration subtype S, S'Enum_Rep denotes a function with the following specification: function S'Enum_Rep (Arg : S'Base) return universal_integer; The function returns the representation value for the given enumeration value. This will be equal to the 'Pos value in the absence of an enumeration representation clause. This is a static attribute (i.e. the result is static if the argument is static). Fixed_Value For every fixed-point type S, S'Fixed_Value denotes a function with the following specification: function S'Fixed_Value (Arg : universal_integer) return S; The value returned is the fixed-point value V such that V = Arg * S'Small The effect is thus equivalent to first converting the argument to the integer type used to represent S, and then doing an unchecked conversion to the fixed-point type. This attribute is primarily intended for use in implementation of the input-output functions for fixed-point values. Img The 'Img function is defined for any prefix, P, that denotes an object of scalar type T. P'Img is equivalent to T'Image (P). This is convenient for debugging. For example: Put_Line ("X = " & X'Img); has the same meaning as the more verbose: Put_Line ("X = " & Temperature_Type'Image (X)); where Temperature_Type is the subtype of the object X. Integer_Value For every integer type S, S'Integer_Value denotes a function with the following specification: function S'Integer_Value (Arg : universal_fixed) return S; The value returned is the integer value V, such that Arg = V * fixed-type'Small The effect is thus equivalent to first doing an unchecked convert from the fixed-point type to its corresponding implementation type, and then converting the result to the target integer type. This attribute is primarily intended for use in implementation of the standard input-output functions for fixed-point values. Max_Interrupt_Priority Standard'Max_Interrupt_Priority (Standard is the only permissible prefix), provides the value System.Max_Interrupt_Priority, and is intended primarily for constructing this definition in package System (see note above in Default_Bit_Order description}. This is a static attribute. Max_Priority Standard'Max_Priority (Standard is the only permissible prefix) provides the value System.Max_Priority, and is intended primarily for constructing this definition in package System (see note above in Default_Bit_Order description). This is a static attribute. Maximum_Alignment Standard'Maximum_Alignment (Standard is the only permissible prefix) provides the maximum useful alignment value for the target. This is a static value that can be used to specify the alignment for an object, guaranteeing that it is properly aligned in all cases. The time this is useful is when an external object is imported and its alignment requirements are unknown. This is a static attribute. Object_Size Type'Object_Size is the same as Type'Size for all types except fixed-point types and discrete types. For fixed-point types and discrete types, this attribute gives the size used for default allocation of objects and components of the size. It may be set for any subtype (even a non-first subtype). See section on Size handling for further details. Passed_By_Reference T'Passed_By_Reference for any subtype T returns a boolean value that is true if the type is normally passed by reference and false if the type is normally passed by copy in calls. For scalar types, the result is always False and is static. For non-scalar types, the result is non-static (since it is computed by Gigi). Range_Length T'Range_Length for any discrete type T yields the number of values represented by the subtype (zero for a null range). The result is static for static subtypes. Note that Range_Length applied to the index subtype of a one dimensional array always gives the same result as Range applied to the array itself. Storage_Unit Standard'Storage_Unit (Standard is the only permissible prefix) provides the value System.Storage_Unit, and is intended primarily for constructing this definition in package System (see note above in Default_Bit_Order description). The is a static attribute. Tick Standard'Tick (Standard is the only permissible prefix) provides the value System.Tick, and is intended primarily for constructing this definition in package System (see note above in description of Default_Bit_Order). This is a static attribute. Universal_Literal_String The prefix of 'Universal_Literal_String must be a named number. The static result is the string consisting of the characters of the number as defined in the original source. This allows the user program to access the actual text of named numbers without intermediate conversions and without the need to enclose the strings in quotes (which would preclude their use as numbers). This is used internally for the construction of values of the floating-point attributes from the file ttypef.ads, but may also be used by user programs. Unrestricted_Access The Unrestricted_Access attribute is similar to Access except that all accessibility and aliased view checks are omitted. This is very much a user-beware attribute. Basically its status is very similar to Address, for which it is a desirable replacement where the value desired is an access type. In other words, its effect is identical to first taking 'Address and then doing an unchecked conversion to a desired access type. Note that in GNAT, but not necessarily in other implementations, the use of static chains for inner level subprograms means that Unrestricted_Access applied to a subprogram yields a value that can be called as long as the subprogram is in scope (normal Ada 95 accessibility rules restrict this usage). Value_Size Type'Value_Size is the number of bits required to represent a value of the given subtype. It is the same as Type'Size, but, unlike Size, may be set for non-first subtypes. See section on Size handling for further details. Word_Size Standard'Word_Size (Standard is the only permissible prefix) provides the value System.Word_Size, and is intended primarily for constructing this definition in package System (see note above in Default_Bit_Order description). This is a static attribute.